﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Teigha.Core;

namespace Teigha.TD
{
	public class ExDbCommandContext : IDisposable
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public ExDbCommandContext(IntPtr cPtr, bool cMemoryOwn)
		{
			this.swigCMemOwn = cMemoryOwn;
			this.swigCPtr = new HandleRef(this, cPtr);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static HandleRef getCPtr(ExDbCommandContext obj)
		{
			if (obj != null)
			{
				return obj.swigCPtr;
			}
			return new HandleRef(null, IntPtr.Zero);
		}

		~ExDbCommandContext()
		{
			this.Dispose();
		}

		public virtual void Dispose()
		{
			if (this.swigCPtr.Handle != IntPtr.Zero)
			{
				if (this.swigCMemOwn)
				{
					lock (this.locker)
					{
						if (this.swigCPtr.Handle != IntPtr.Zero && this.swigCMemOwn)
						{
							this.swigCMemOwn = false;
							TD_DbPINVOKE.delete_ExDbCommandContext(this.swigCPtr);
						}
					}
					this.swigCMemOwn = false;
				}
				this.swigCPtr = new HandleRef(null, IntPtr.Zero);
			}
			GC.SuppressFinalize(this);
		}

		public static OdDbCommandContext createObject(OdEdBaseIO pIOStream, OdDbDatabase pDb)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_createObject__SWIG_0(OdEdBaseIO.getCPtr(pIOStream), OdDbDatabase.getCPtr(pDb));
			OdDbCommandContext result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdDbCommandContext createObject(OdEdBaseIO pIOStream, OdRxObject pRxDb)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_createObject__SWIG_1(OdEdBaseIO.getCPtr(pIOStream), OdRxObject.getCPtr(pRxDb));
			OdDbCommandContext result;
			if (currentTransaction != null)
			{
                currentTransaction.AddObject((OdDbCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public static OdDbCommandContext createObject(OdEdBaseIO pIOStream)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_createObject__SWIG_2(OdEdBaseIO.getCPtr(pIOStream));
			OdDbCommandContext result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdDbCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdDbCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdDbCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdRxObject baseDatabase()
		{
			OdRxObject result = Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.ExDbCommandContext_baseDatabase(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void reset(OdEdBaseIO pIOStream, OdRxObject pRxDb)
		{
			TD_DbPINVOKE.ExDbCommandContext_reset(this.swigCPtr, OdEdBaseIO.getCPtr(pIOStream), OdRxObject.getCPtr(pRxDb));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public OdEdBaseIO baseIO()
		{
			OdEdBaseIO result = (OdEdBaseIO)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.ExDbCommandContext_baseIO(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdEdCommandContext cloneObject(OdEdBaseIO pIOStream, OdRxObject pRxDb)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_cloneObject__SWIG_0(this.swigCPtr, OdEdBaseIO.getCPtr(pIOStream), OdRxObject.getCPtr(pRxDb));
			OdEdCommandContext result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdEdCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdEdCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdEdCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdEdCommandContext cloneObject(OdEdBaseIO pIOStream)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_cloneObject__SWIG_1(this.swigCPtr, OdEdBaseIO.getCPtr(pIOStream));
			OdEdCommandContext result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdEdCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdEdCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdEdCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdEdCommandContext cloneObject()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_cloneObject__SWIG_2(this.swigCPtr);
			OdEdCommandContext result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdEdCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdEdCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdEdCommandContext)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdEdUserIO userIO()
		{
			OdEdUserIO result = (OdEdUserIO)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.ExDbCommandContext_userIO(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdEdFunctionIO funcIO()
		{
			OdEdFunctionIO result = (OdEdFunctionIO)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.ExDbCommandContext_funcIO(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setParam(OdRxObject pParamObj)
		{
			TD_DbPINVOKE.ExDbCommandContext_setParam(this.swigCPtr, OdRxObject.getCPtr(pParamObj));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdRxObject param()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_param(this.swigCPtr);
			OdRxObject result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setResult(OdRxObject pResultObj)
		{
			TD_DbPINVOKE.ExDbCommandContext_setResult(this.swigCPtr, OdRxObject.getCPtr(pResultObj));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdRxObject result()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_result(this.swigCPtr);
			OdRxObject result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setArbitraryData(string fileName, OdRxObject pDataObj)
		{
			TD_DbPINVOKE.ExDbCommandContext_setArbitraryData(this.swigCPtr, fileName, OdRxObject.getCPtr(pDataObj));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdRxObject arbitraryData(string fileName)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_arbitraryData(this.swigCPtr, fileName);
			OdRxObject result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdSelectionSet pickfirst()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_pickfirst(this.swigCPtr);
			OdSelectionSet result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPickfirst(OdSelectionSet pSSet)
		{
			TD_DbPINVOKE.ExDbCommandContext_setPickfirst(this.swigCPtr, OdSelectionSet.getCPtr(pSSet));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdSelectionSet previousSelection()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_previousSelection(this.swigCPtr);
			OdSelectionSet result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setPreviousSelection(OdSelectionSet pSSet)
		{
			TD_DbPINVOKE.ExDbCommandContext_setPreviousSelection(this.swigCPtr, OdSelectionSet.getCPtr(pSSet));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdUnitsFormatter baseFormatter()
		{
			OdUnitsFormatter result = (OdUnitsFormatter)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.ExDbCommandContext_baseFormatter(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdDbUnitsFormatter formatter()
		{
			OdDbUnitsFormatter result = (OdDbUnitsFormatter)Teigha.Core.Helpers.odrxCreateObjectInternal(TD_DbPINVOKE.ExDbCommandContext_formatter(this.swigCPtr), false);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void putString(string arg0)
		{
			TD_DbPINVOKE.ExDbCommandContext_putString(this.swigCPtr, arg0);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual int getInt(string prompt, int options, int defVal, string keywords, OdEdIntegerTracker pTracker)
		{
			int result = TD_DbPINVOKE.ExDbCommandContext_getInt__SWIG_0(this.swigCPtr, prompt, options, defVal, keywords, OdEdIntegerTracker.getCPtr(pTracker));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual int getInt(string prompt, int options, int defVal, string keywords)
		{
			int result = TD_DbPINVOKE.ExDbCommandContext_getInt__SWIG_1(this.swigCPtr, prompt, options, defVal, keywords);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual int getInt(string prompt, int options, int defVal)
		{
			int result = TD_DbPINVOKE.ExDbCommandContext_getInt__SWIG_2(this.swigCPtr, prompt, options, defVal);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual int getInt(string prompt, int options)
		{
			int result = TD_DbPINVOKE.ExDbCommandContext_getInt__SWIG_3(this.swigCPtr, prompt, options);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual int getInt(string prompt)
		{
			int result = TD_DbPINVOKE.ExDbCommandContext_getInt__SWIG_4(this.swigCPtr, prompt);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getReal(string prompt, int options, double defVal, string keywordList, OdEdRealTracker pTracker)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getReal__SWIG_1(this.swigCPtr, prompt, options, defVal, keywordList, OdEdRealTracker.getCPtr(pTracker));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getReal(string prompt, int options, double defVal, string keywordList)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getReal__SWIG_2(this.swigCPtr, prompt, options, defVal, keywordList);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getReal(string prompt, int options, double defVal)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getReal__SWIG_3(this.swigCPtr, prompt, options, defVal);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getReal(string prompt, int options)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getReal__SWIG_4(this.swigCPtr, prompt, options);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getReal(string prompt)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getReal__SWIG_5(this.swigCPtr, prompt);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual string getString(string prompt, int options, string pDefVal, string keywords, OdEdStringTracker pTracker)
		{
			string result = TD_DbPINVOKE.ExDbCommandContext_getString__SWIG_0(this.swigCPtr, prompt, options, pDefVal, keywords, OdEdStringTracker.getCPtr(pTracker));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual string getString(string prompt, int options, string pDefVal, string keywords)
		{
			string result = TD_DbPINVOKE.ExDbCommandContext_getString__SWIG_1(this.swigCPtr, prompt, options, pDefVal, keywords);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual string getString(string prompt, int options, string pDefVal)
		{
			string result = TD_DbPINVOKE.ExDbCommandContext_getString__SWIG_2(this.swigCPtr, prompt, options, pDefVal);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual string getString(string prompt, int options)
		{
			string result = TD_DbPINVOKE.ExDbCommandContext_getString__SWIG_3(this.swigCPtr, prompt, options);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual string getString(string prompt)
		{
			string result = TD_DbPINVOKE.ExDbCommandContext_getString__SWIG_4(this.swigCPtr, prompt);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual int getKeyword(string prompt, string keywords, int defRes, int options, OdEdIntegerTracker pTracker)
		{
			int result = TD_DbPINVOKE.ExDbCommandContext_getKeyword__SWIG_0(this.swigCPtr, prompt, keywords, defRes, options, OdEdIntegerTracker.getCPtr(pTracker));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual int getKeyword(string prompt, string keywords, int defRes, int options)
		{
			int result = TD_DbPINVOKE.ExDbCommandContext_getKeyword__SWIG_1(this.swigCPtr, prompt, keywords, defRes, options);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual int getKeyword(string prompt, string keywords, int defRes)
		{
			int result = TD_DbPINVOKE.ExDbCommandContext_getKeyword__SWIG_2(this.swigCPtr, prompt, keywords, defRes);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual int getKeyword(string prompt, string keywords)
		{
			int result = TD_DbPINVOKE.ExDbCommandContext_getKeyword__SWIG_3(this.swigCPtr, prompt, keywords);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getAngle(string prompt, int options, double defVal, string keywords, OdEdRealTracker pTracker)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getAngle__SWIG_0(this.swigCPtr, prompt, options, defVal, keywords, OdEdRealTracker.getCPtr(pTracker));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getAngle(string prompt, int options, double defVal, string keywords)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getAngle__SWIG_1(this.swigCPtr, prompt, options, defVal, keywords);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getAngle(string prompt, int options, double defVal)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getAngle__SWIG_2(this.swigCPtr, prompt, options, defVal);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getAngle(string prompt, int options)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getAngle__SWIG_3(this.swigCPtr, prompt, options);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getAngle(string prompt)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getAngle__SWIG_4(this.swigCPtr, prompt);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGePoint3d getLASTPOINT()
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.ExDbCommandContext_getLASTPOINT(this.swigCPtr), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual void setLASTPOINT(OdGePoint3d val)
		{
			TD_DbPINVOKE.ExDbCommandContext_setLASTPOINT(this.swigCPtr, OdGePoint3d.getCPtr(val));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public virtual OdEdPointDefTracker createRubberBand(OdGePoint3d arg0, OdGsModel pModel)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_createRubberBand__SWIG_0(this.swigCPtr, OdGePoint3d.getCPtr(arg0), OdGsModel.getCPtr(pModel));
			OdEdPointDefTracker result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdEdPointDefTracker createRubberBand(OdGePoint3d arg0)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_createRubberBand__SWIG_1(this.swigCPtr, OdGePoint3d.getCPtr(arg0));
			OdEdPointDefTracker result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdEdPointDefTracker createRectFrame(OdGePoint3d arg0, OdGsModel pModel)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_createRectFrame__SWIG_0(this.swigCPtr, OdGePoint3d.getCPtr(arg0), OdGsModel.getCPtr(pModel));
			OdEdPointDefTracker result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdEdPointDefTracker createRectFrame(OdGePoint3d arg0)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_createRectFrame__SWIG_1(this.swigCPtr, OdGePoint3d.getCPtr(arg0));
			OdEdPointDefTracker result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdEdPointDefTracker)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGePoint3d getPoint(string prompt, int options, OdGePoint3d pDefVal, string keywords, OdEdPointTracker arg4)
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.ExDbCommandContext_getPoint__SWIG_0(this.swigCPtr, prompt, options, OdGePoint3d.getCPtr(pDefVal), keywords, OdEdPointTracker.getCPtr(arg4)), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGePoint3d getPoint(string prompt, int options, OdGePoint3d pDefVal, string keywords)
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.ExDbCommandContext_getPoint__SWIG_1(this.swigCPtr, prompt, options, OdGePoint3d.getCPtr(pDefVal), keywords), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGePoint3d getPoint(string prompt, int options, OdGePoint3d pDefVal)
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.ExDbCommandContext_getPoint__SWIG_2(this.swigCPtr, prompt, options, OdGePoint3d.getCPtr(pDefVal)), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGePoint3d getPoint(string prompt, int options)
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.ExDbCommandContext_getPoint__SWIG_3(this.swigCPtr, prompt, options), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdGePoint3d getPoint(string prompt)
		{
			OdGePoint3d result = new OdGePoint3d(TD_DbPINVOKE.ExDbCommandContext_getPoint__SWIG_4(this.swigCPtr, prompt), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getDist(string prompt, int options, double defVal, string keywords, OdEdRealTracker pTracker)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getDist__SWIG_0(this.swigCPtr, prompt, options, defVal, keywords, OdEdRealTracker.getCPtr(pTracker));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getDist(string prompt, int options, double defVal, string keywords)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getDist__SWIG_1(this.swigCPtr, prompt, options, defVal, keywords);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getDist(string prompt, int options, double defVal)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getDist__SWIG_2(this.swigCPtr, prompt, options, defVal);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getDist(string prompt, int options)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getDist__SWIG_3(this.swigCPtr, prompt, options);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual double getDist(string prompt)
		{
			double result = TD_DbPINVOKE.ExDbCommandContext_getDist__SWIG_4(this.swigCPtr, prompt);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual string getFilePath(string prompt, int options, string dialogCaption, string defExt, string fileName, string filter, string keywords, OdEdStringTracker pTracker)
		{
			string result = TD_DbPINVOKE.ExDbCommandContext_getFilePath__SWIG_0(this.swigCPtr, prompt, options, dialogCaption, defExt, fileName, filter, keywords, OdEdStringTracker.getCPtr(pTracker));
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual string getFilePath(string prompt, int options, string dialogCaption, string defExt, string fileName, string filter, string keywords)
		{
			string result = TD_DbPINVOKE.ExDbCommandContext_getFilePath__SWIG_1(this.swigCPtr, prompt, options, dialogCaption, defExt, fileName, filter, keywords);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual string getFilePath(string prompt, int options, string dialogCaption, string defExt, string fileName, string filter)
		{
			string result = TD_DbPINVOKE.ExDbCommandContext_getFilePath__SWIG_2(this.swigCPtr, prompt, options, dialogCaption, defExt, fileName, filter);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColorBase getCmColor(string sPrompt, int options, OdCmColorBase pDefVal, string sKeywords, OdEdColorTracker pTracker)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.ExDbCommandContext_getCmColor__SWIG_0(this.swigCPtr, sPrompt, options, OdCmColorBase.getCPtr(pDefVal), sKeywords, OdEdColorTracker.getCPtr(pTracker));
			OdCmColorBase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdCmColorBase(cPtr, true));
				result = new OdCmColorBase(cPtr, false);
			}
			else
			{
				result = new OdCmColorBase(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColorBase getCmColor(string sPrompt, int options, OdCmColorBase pDefVal, string sKeywords)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.ExDbCommandContext_getCmColor__SWIG_1(this.swigCPtr, sPrompt, options, OdCmColorBase.getCPtr(pDefVal), sKeywords);
			OdCmColorBase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdCmColorBase(cPtr, true));
				result = new OdCmColorBase(cPtr, false);
			}
			else
			{
				result = new OdCmColorBase(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColorBase getCmColor(string sPrompt, int options, OdCmColorBase pDefVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.ExDbCommandContext_getCmColor__SWIG_2(this.swigCPtr, sPrompt, options, OdCmColorBase.getCPtr(pDefVal));
			OdCmColorBase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdCmColorBase(cPtr, true));
				result = new OdCmColorBase(cPtr, false);
			}
			else
			{
				result = new OdCmColorBase(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColorBase getCmColor(string sPrompt, int options)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.ExDbCommandContext_getCmColor__SWIG_3(this.swigCPtr, sPrompt, options);
			OdCmColorBase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdCmColorBase(cPtr, true));
				result = new OdCmColorBase(cPtr, false);
			}
			else
			{
				result = new OdCmColorBase(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColorBase getCmColor(string sPrompt)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr cPtr = TD_DbPINVOKE.ExDbCommandContext_getCmColor__SWIG_4(this.swigCPtr, sPrompt);
			OdCmColorBase result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject(new OdCmColorBase(cPtr, true));
				result = new OdCmColorBase(cPtr, false);
			}
			else
			{
				result = new OdCmColorBase(cPtr, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor getColor(string prompt, int options, OdCmColor pDefVal, string keywordList, OdEdColorTracker pTracker)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.ExDbCommandContext_getColor__SWIG_0(this.swigCPtr, prompt, options, OdCmColor.getCPtr(pDefVal), keywordList, OdEdColorTracker.getCPtr(pTracker)), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor getColor(string prompt, int options, OdCmColor pDefVal, string keywordList)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.ExDbCommandContext_getColor__SWIG_1(this.swigCPtr, prompt, options, OdCmColor.getCPtr(pDefVal), keywordList), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor getColor(string prompt, int options, OdCmColor pDefVal)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.ExDbCommandContext_getColor__SWIG_2(this.swigCPtr, prompt, options, OdCmColor.getCPtr(pDefVal)), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor getColor(string prompt, int options)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.ExDbCommandContext_getColor__SWIG_3(this.swigCPtr, prompt, options), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdCmColor getColor(string prompt)
		{
			OdCmColor result = new OdCmColor(TD_DbPINVOKE.ExDbCommandContext_getColor__SWIG_4(this.swigCPtr, prompt), true);
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdSelectionSet select(string prompt, int options, OdSelectionSet pDefVal, string keywords, OdSSetTracker pTracker)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_select__SWIG_0(this.swigCPtr, prompt, options, OdSelectionSet.getCPtr(pDefVal), keywords, OdSSetTracker.getCPtr(pTracker));
			OdSelectionSet result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdSelectionSet select(string prompt, int options, OdSelectionSet pDefVal, string keywords)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_select__SWIG_1(this.swigCPtr, prompt, options, OdSelectionSet.getCPtr(pDefVal), keywords);
			OdSelectionSet result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdSelectionSet select(string prompt, int options, OdSelectionSet pDefVal)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_select__SWIG_2(this.swigCPtr, prompt, options, OdSelectionSet.getCPtr(pDefVal));
			OdSelectionSet result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdSelectionSet select(string prompt, int options)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_select__SWIG_3(this.swigCPtr, prompt, options);
			OdSelectionSet result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdSelectionSet select(string prompt)
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_select__SWIG_4(this.swigCPtr, prompt);
			OdSelectionSet result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public virtual OdSelectionSet select()
		{
			MemoryManager memoryManager = MemoryManager.GetMemoryManager();
			MemoryTransaction currentTransaction = memoryManager.GetCurrentTransaction();
			IntPtr p = TD_DbPINVOKE.ExDbCommandContext_select__SWIG_5(this.swigCPtr);
			OdSelectionSet result;
			if (currentTransaction != null)
			{
				currentTransaction.AddObject((OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true));
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, false);
			}
			else
			{
				result = (OdSelectionSet)Teigha.Core.Helpers.odrxCreateObjectInternal(p, true);
			}
			if (TD_DbPINVOKE.SWIGPendingException.Pending)
			{
				throw TD_DbPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private object locker = new object();

		private HandleRef swigCPtr;

		protected bool swigCMemOwn;
	}
}
